package com.easysettle.service

import android.app.Activity
import android.content.Context
import android.content.pm.PackageManager
import android.util.Log
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.easysettle.data.ProductDataManager
import com.easysettle.data.ShoppingCart
import com.easysettle.model.CartItem
import com.easysettle.model.Product
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.Executors

/**
 * 主服务类
 * 作为业务逻辑的核心，连接数据层和视图层
 */
class MainService(private val context: Context) {
    // 商品数据管理器
    private val productDataManager: ProductDataManager = ProductDataManager.getInstance(context)
    // 购物车
    private val shoppingCart: ShoppingCart = ShoppingCart()
    // 线程池，用于执行后台任务
    private val executorService = Executors.newSingleThreadExecutor()

    companion object {
        // 日志标签
        private const val TAG = "MainService"
        // 权限请求码
        const val PERMISSION_CAMERA_REQUEST_CODE = 101
        const val PERMISSION_STORAGE_REQUEST_CODE = 102
    }

    /**
     * 检查是否有指定的权限
     */
    fun hasPermission(permission: String): Boolean {
        return ContextCompat.checkSelfPermission(
            context,
            permission
        ) == PackageManager.PERMISSION_GRANTED
    }

    /**
     * 请求权限
     */
    fun requestPermission(permission: String, requestCode: Int) {
        if (context is Activity) {
            ActivityCompat.requestPermissions(
                context,
                arrayOf(permission),
                requestCode
            )
        }
    }

    /**
     * 获取所有商品
     */
    fun getAllProducts(): List<Product> {
        return productDataManager.getAllProducts()
    }

    /**
     * 根据ID查找商品
     */
    fun getProductById(id: String): Product? {
        return productDataManager.getProductById(id)
    }

    /**
     * 根据条形码查找商品
     */
    fun getProductByBarcode(barcode: String): Product? {
        return productDataManager.getProductByBarcode(barcode)
    }

    /**
     * 根据ID或名称模糊查询商品
     */
    fun searchProducts(query: String): List<Product> {
        return productDataManager.searchProducts(query)
    }

    /**
     * 获取下一个可用的商品ID
     */
    fun getNextAvailableId(): String {
        return productDataManager.getNextAvailableId()
    }

    /**
     * 添加新商品
     */
    fun addProduct(product: Product, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = productDataManager.addProduct(product)
            onComplete(result)
        }
    }

    /**
     * 更新商品信息
     */
    fun updateProduct(product: Product, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = productDataManager.updateProduct(product)
            onComplete(result)
        }
    }

    /**
     * 删除商品
     */
    fun deleteProduct(productId: String, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = productDataManager.deleteProduct(productId)
            onComplete(result)
        }
    }

    /**
     * 添加商品到购物车（同步版本）
     */
    fun addToCart(product: Product, quantity: Int = 1): Boolean {
        return shoppingCart.addProduct(product, quantity)
    }

    /**
     * 添加商品到购物车（异步版本）
     */
    fun addToCart(product: Product, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            // 显式传递数量参数1，确保商品被正确添加到购物车
            val result = shoppingCart.addProduct(product, 1)
            onComplete(result)
        }
    }

    /**
     * 从购物车中移除商品（同步版本）
     */
    fun removeFromCart(productId: String): Boolean {
        return shoppingCart.removeProduct(productId)
    }

    /**
     * 从购物车中移除商品（异步版本）
     */
    fun removeFromCart(productId: String, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = shoppingCart.removeProduct(productId)
            onComplete(result)
        }
    }

    /**
     * 更新购物车中商品的数量
     */
    fun updateCartItemQuantity(productId: String, quantity: Int, onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = if (quantity > 0) {
                shoppingCart.updateQuantity(productId, quantity)
            } else {
                shoppingCart.removeProduct(productId)
            }
            onComplete(result)
        }
    }

    /**
     * 增加购物车中商品的数量
     */
    fun increaseQuantity(productId: String): Boolean {
        return shoppingCart.increaseQuantity(productId)
    }

    /**
     * 减少购物车中商品的数量
     */
    fun decreaseQuantity(productId: String): Boolean {
        return shoppingCart.decreaseQuantity(productId)
    }

    /**
     * 清空购物车（同步版本）
     */
    fun clearCart(): Boolean {
        return shoppingCart.clearCart()
    }

    /**
     * 清空购物车（异步版本）
     */
    fun clearShoppingCart(onComplete: (Boolean) -> Unit) {
        executorService.execute {
            val result = shoppingCart.clearCart()
            onComplete(result)
        }
    }

    /**
     * 获取购物车中的所有商品项（同步版本）
     */
    fun getCartItems(): List<CartItem> {
        return shoppingCart.getAllItems()
    }

    /**
     * 获取购物车中的所有商品项（异步版本）
     */
    fun getShoppingCartItems(onComplete: (List<com.easysettle.model.CartItem>?) -> Unit) {
        executorService.execute {
            // 直接返回购物车中的原始商品项列表，避免创建新的CartItem对象
            val cartItems = shoppingCart.getAllItems()
            onComplete(cartItems)
        }
    }

    /**
     * 获取购物车的总金额
     */
    fun getCartTotalAmount(): Double {
        return shoppingCart.getTotalAmount()
    }

    /**
     * 检查购物车是否为空
     */
    fun isCartEmpty(): Boolean {
        return shoppingCart.isEmpty()
    }

    /**
     * 生成收据内容
     */
    fun generateReceiptContent(): String {
        val sb = StringBuilder()
        val dateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
        val currentDate = dateFormat.format(Date())

        // 收据头部
        sb.appendLine("小超市购物清单")
        sb.appendLine("--------------------")
        sb.appendLine("日期: $currentDate")
        sb.appendLine("--------------------")

        // 商品列表
        val cartItems = shoppingCart.getAllItems()
        cartItems.forEach {
            val productName = it.product.name
            val quantity = it.quantity
            val price = it.product.price
            val subtotal = it.getSubtotal()
            sb.appendLine("$productName × $quantity: ¥${String.format("%.2f", subtotal)}")
        }

        // 合计
        sb.appendLine("--------------------")
        sb.appendLine("小计: ¥${shoppingCart.getFormattedTotalAmount()}")
        sb.appendLine("总计: ¥${shoppingCart.getFormattedTotalAmount()}")
        sb.appendLine("--------------------")
        sb.appendLine("感谢您的光临！")

        return sb.toString()
    }

    /**
     * 执行结算操作
     */
    fun checkout(): Boolean {
        try {
            // 在实际应用中，这里可能需要与支付系统集成
            Log.d(TAG, "结算成功，总金额: ¥${shoppingCart.getFormattedTotalAmount()}")
            return true
        } catch (e: Exception) {
            Log.e(TAG, "结算失败", e)
            return false
        }
    }

    /**
     * 清理资源
     */
    fun cleanup() {
        executorService.shutdown()
    }
}